Rhapsody Developer Release 2 Copyright 1998 by Apple Computer, Inc. All Rights Reserved.
The Application Framework (sometimes referred to as the AppKit) is one of the core Yellow Box frameworks. It provides functionality and associated APIs for applications, including objects for graphical user interfaces (GUIs), event-handling mechanisms, application services , and drawing and image composition facilities. It is also a cross-platform framework; thus all features described below are available both on Rhapsody and Yellow Box for Windows unless otherwise noted. In addition, it is possible to access virtually all of the classes and protocols in the Application framework using Java.
The notes below are split into three sections:
The Application Kit includes these new classes, features, and changes since the first Developer Release. Many of the new features have been documented, so please refer to the documentation for more detail.
The Java APIs to the Yellow Box, which were distributed in their alpha form in the first Developer Release, have undergone some changes and are now considerably more robust and finalized. Please see the Java APIs release note for details.
The new NSDocument, NSDocumentController, and NSWindowController classes ease the task of creating document-based applications. These classes encompass a lot of the behavior that applications commonly implement to deal with documents. Document-based applications that use these classes will be better suited to take automatic advantage of new features added to the Yellow Box.
Instances of NSDocument represent documents. NSDocument is abstract; you subclass it to add storage for the document and behaviors such as reading and writing. An NSDocument appears in the responder chain right after its window's delegate, and the NSDocument is set up to be the first-responder target for various actions such as save, revert, and print. In addition, NSDocument manages its window's edited status and implements much of the behavior required for undo and redo operations.
Each application has one instance of NSDocumentController, which manages the list of documents and implements application-wide behavior.
NSWindowController provides basic nib-file and window management. For simple situations (one document, one window), you will usually have one instance of NSWindowController per document. An NSWindowController can also be used to manage windows in non-document-based applications. Subclassing is optional.
A new project type, "Document Based Application," facilitates the initial setup required to create an application based on these new classes.
A known problem in the current release is a bug in
NSDocumentController that causes it to raise an exception if it tries
to create an instance of an NSDocument subclass and the creation of
the instance fails. This happens if your NSDocument subclass
overrides any read... or load... method and
returns NO. For now, you can work around this problem by not
returning NO from these methods under normal circumstances. The
problem will be fixed in a future release.
To better support the new document object and the Finder (in upcoming releases), some changes were made in the contents of the Info.plist and CustomInfo.plist files found in application wrappers and bundles. See the release note on the Information Property List Format for details.
Enterprise Object Framework's EOUndoManager has been modified and made a new Foundation class, NSUndoManager. This class makes it easier for applications to support undo and redo operations. Clients register callbacks that the undo manager invokes when users request an undo or redo operation. NSUndoManager supports grouping and multiple levels of undo.
NSResponder now provides a method called undoManager;
clients should use this method to get access to an NSUndoManager. The
default behavior in NSResponder is to call the next responder; this
usually ends up in NSWindow, which is in the responder chain. The
default behavior of NSWindow is a bit more complicated; if the window
has a window controller with a document, NSWindow implements this
method by first looking to see if its document has an undo manager
and returning it if that is so. Otherwise, NSWindow invokes the new
delegate method undoManagerForWindow: If the delegate
doesn't implement this method NSWindow creates and returns its own
NSUndoManager.
The text system now also supports undo and redo operations.
Although this release contains no scripting features, the release note Scripting, Documents, Undo, and Your Application contains information that helps you design your application so that it will be scriptable when the Yellow Box does provide scriptability. This release note also discusses the document architeture and undo features in some detail.
The Application Kit and Foundation now provide more multithread
safety, enough to support AWT's multithreaded drawing demands and
allow developers to do a variety of tasks using multiple threads.
Drawing from multiple threads is supported as long as each thread
uses its own connection to the window server; this is easily
accomplished by using the NSApplication factory method
detachDrawingThread:toTarget:withObject:.
For additional release notes on threading support please see ThreadSupport.html.
NSStatusBar and NSStatusBarItem are two new classes that provide a way to add items to a system-wide status area. These status-bar classes replace the use of application tiles as well as providing extended functionality. An application can add status-bar items that are strings, images, tool tips, or menus and can invoke an action in a specified target when users click on a status-bar item.
The same API is available on both Macintosh and Windows. On the Macintosh, the items appear on the right hand side of the menu bar. Under Windows, the status items appear as part of the taskbar notification area (usually right side of taskbar). The custom view feature is not supported under Windows.
On Rhapsody, the Apple menu is now automatically filled with a default list of applications and two special entries that represent the lists of recently used applications and documents. In this release there is no editor with which users can configure the contents of the Apple menu, and both the contents of the list and the storage for the contents is subject to change in the future.
The Application Kit "hack" of changing the first top-level menu to an Apple menu if its title is "Info" still works in this release; however, you should switch your menus to use a real Apple menu.
Any Rhapsody menu that is a part of an application's main menu can be torn off. To tear off a menu start tracking in it as if you were going to choose an item and drag off the bottom of the menu a little distance. The mouse button must be down to tear off a menu. The menus you tear off in an application are remembered and restored as you quit and relaunch the application.
Menus now support keyboard UI: While a menu is tracking you can now use the arrow keys to navigate. Since there is currently no way to start tracking the main menu through the keyboard, this isn't yet very useful for normal menus, but it means that you can use the keyboard to choose items in a popup or pulldown menu. When the focus is on an NSPopUpButton, pressing the space bar pops the menu up. Then you can use the arrow keys to move between items; press the space bar again to choose an item.
Control-click now show the context menu for a view if the view has
one. The Control-click is not seen (as a mouseDown:) by
views that have context menus. Views that do not have context menus
still receive mouseDown: for Control-clicks. However,
using Control as a mouse modifier is discouraged, even if you don't
have context menus. Over time, Yellow Box applications provided by
Apple will migrate away from using Control-click for anything but
context menus.
User key-equivalent overrides: This feature is implemented but the UI for setting them is not in this release.
You can now specify the arrow position for bezel style and borderless pop-up menus.
You can now independently set the horizontal and vertical line and page scroll amounts.
NSSplitView has additional delegate methods to allow you to constrain the resizing and collapsing of the view.
The new convenience method
selectTabViewItemWithIdentifier: allows you to select a
tab item by its identifier. As with the other methods in NSTabView,
this method raises an exception if the identifier is invalid.
In Developer Release 1 on Rhapsody platforms, application
delegates did not receive applicationShouldTerminate: on
power-off or logout events in addition to normal application
termination. This now works properly. If the application delegate
implements this method and returns NO, then the logout or power-off
is cancelled.
Applications that need to distinguish between a termination
associated with the end of a login session and a termination through
a Quit (or Exit) command could do this by registering for the
NSWorkspaceWillPowerOffNotification. This notification
is posted prior to calling applicationShouldTerminate:.
Additional relevant events that occur later in the termination
sequence are the posting of an
NSApplicationWillTerminateNotification and a
corresponding message to the application delegate of
applicationWillTerminate:, if it implements the method.
For documents managed by an NSDocumentController, it is not necessary for the application delegate to become involved in the save or cancel process.
Buttons include a new feature makes the border of the button
visible only when the button is enabled and the mouse is over the
button. You can enable or disable this feature by invoking the method
setShowsBorderOnlyWhileMouseInside:; the current setting
of this attribute is returned by the method
showsBorderOnlyWhileMouseInside. These two method are
available in both NSButton and NSButtonCell and this setting is
archived and restored. When you are dealing with matrices, invoke the
cell methods directly.
You can override the mouseEntered: and
mouseExited: methods added to NSButtonCell in order to
make additional appearance changes. These methods are invoked when
the button cell is enabled, the
showsBorderOnlyWhileMouseInside flag is set to YES, and
the mouse enters or exits the button.
The new method
colorizeByMappingGray:toColor:blackMapping:whiteMapping:
supports colorization of images. This method primarily maps grayscale
user interface component images to different color schemes.
In this release NSBitmapImageRep has some preliminary support for ColorSync profiles in TIFF files. The profile is loaded and used if possible. It is not retained on save. Also, it works only on the PowerPC architecture.
As mentioned in the Developer Release 1 notes, NSBitmapImageRep now supports JPEG, GIF, and PNG reading and writing. This support is not finalized and will probably change for the first Customer Release to include additional formats using QuickTime codecs.
Because different image formats contain additional information,
this information is stored as NSBitmapImageRep properties. You can
set these properties in the image by using the
setProperty:withValue: method and get the properties
with valueForProperty:, or you can add or override the
properties when creating the representation using
representationOfImageRepsInArray:usingType:properties:
and representationUsingType:properties: methods. The
properties are stored in an NSDictionary using an NSString for the
key. The following key/value pairs are currently defined:
NSImageCompressionMethod: -- The TIFF compression
method for TIFF files. The enumerated value is stored in an
NSNumber.
NSImageCompressionFactor: -- The TIFF and JPEG
compression factor. The float value is stored in an NSNumber.
NSImageDitherTransparency: -- Used for GIF output
only. It is a boolean value stored in an NSNumber. If true,
transparency is dithered to get an alpha channel effect.
NSImageRGBColorTable: -- For GIF input and
output. It consists of a 768 byte NSData object that contains a
packed RGB table with each component being 8 bits.
NSImageInterlaced: -- For PNG output; this value
indicates that the output image is to be interlaced. It is a
boolean value stored in an NSNumber.]
Several new factory methods support additional system colors:
keyboardFocusIndicatorColor: -- Color to use to
draw the keyboard focus ring around text fields and buttons.
headerColor: -- Background color for header cells
in Table/OutlineView.
headerTextColor: -- Text color for header cells
in Table/OutlineView
Rhapsody now supports dynamic updating of color schemes; if the
user changes any of the system colors in the Preferences application,
applications will be updated dynamically. If you create or cache any
custom colors based on system colors, you might need to listen to the
NSSystemColorsDidChangeNotification and take appropriate
action when the color scheme is updated.
As discussed above, NSBitmapImageRep also provides a method to colorize images; this method might come in handy when you are adopting bitmap images in the user interface to new color schemes.
The typedefs NSPointArray, NSSizeArray, NSRectArray,
and NSRangeArray are added to Foundation and the AppKit
to indicate methods and functions that take C-arrays of NSPoint,
NSSize, NSRect, and NSRange.
Similarly, the typedefs NSPointPointer, NSSizePointer,
NSRectPointer, and NSRangePointer are added to
indicate methods and functions that return NSPoints, NSSizes,
NSRects, and NSRanges by reference.
These typedefs do not really change the API, but they do clarify the intentions of the few methods taking pointers to structs, making it possible for the Java bridge to convert them correctly.
The methods availableFontFamilies,
availableMembersOfFontFamily:, and
localizedNameForFamily:face: are added to provide more
information about font families.
NSScreenSaverWindowLevel has been added to allow
developers to place windows above everything else, including menus.
NSDockWindowLevel has been deprecated and should not be
used.
The Application Kit now supports a utility look for panels. This
is typically used for small nonmodal panels that float and hide when
the application is deactivated, such as a tools palette. A utility
window is a floating panel by default, but you can disable this
behavior by invoking setFloatingPanel: with an argument
of NO.
You can create utility windows programmatically with the
NSUtilityWindowMask style (which should be specified in
conjunction with NSTitledWindowMask), or in Interface
Builder, by enabling the "utility window" option in the Panel
Attribute inspector.
The "Minimize" attribute, which was changed to windowshade windows in Developer Release 1, now either minimizes or windowshades depending on the user preference.
A known problem in this release is the behavior of windows marked
as "Visible at launch" in Interface Builder. When an application is
launched they become visible but they do not become key even though
the application is active. For a window to become key,
makeKeyAndOrderFront: must be explicitly invoked.
An NSURL class has been added to the Foundation framework. In this release the class only supports file URLs.
Various classes in the Foundation and Application frameworks have
new APIs that take URLs in addition to file names. For instance,
NSData's initWithContentsOfFile: now has a parallel
initWithContentsOfURL:. You can now get back an array of
URLs from the open panel in place of the array of file names. If your
application starts using these new APIs, it will inherit richer
behavior (such as accessing files and resources over the network)
when NSURL class is expanded in future releases.
NSAttributedString's initWithHTML:documentAttributes:
method has been deprecated in favor of
initWithHTML:baseURL:documentAttributes:, which provides
a way to supply the appropriate base URL.
Please note that the prefix HTML is reserved and in use by the (currently private) HTML framework.This framework is dynamically loaded when the Application framework needs to parse HTML files; any conflicts in global names could lead to problems at that time.
Invoking NSImage's imageNamed:method with images that
don't exist can be costly, forcing a search of the application's main
bundle and the Application framework. If you wish to detect such
calls to this method, run your application with the
NSLogMissingNamedImages default set to YES (as with all
defaults, this can also be specified through the command line).
In Rhapsody and Yellow Box for Windows, the method
setKnobThickness: currently has no effect.
The Foundation framework now contains NSDistributedNotificationCenter, a class for sending notifications between processes on a single machine. In addition to the basic features in NSNotificationCenter, this class provides a way to set a suspension behavior on notifications: You can cause them to be delivered immediately to all applications, or delayed until the applications are not suspended. The Application Kit ensures that applications become suspended when they are deactivated.
Distributed notifications can be expensive if they are sent often and cause the receiving applications to wake up on delivery. For that reason you should use them sparingly and with the suspension behavior generally set to NSNotificationSuspensionBehaviorCoalesce.
There are significant changes in the NSBezierPath APIs, which are not yet documented. Please refer to the header file for the new API.
Compatibility was not maintained between the old and new APIs, so earlier code that used NSBezierPath should be recompiled.
This release introduces some additional input method API. At the
core of interaction, insertText: and
setMarkedText:selectedRange: can receive an instance of
NSAttributedString as their arguments where they were restricted to
NSString in the previous releases. Input servers are expected to
query valid attributes with the
validAttributesForMarkedText method. Currently the
following attributes are supported by NSTextView for marked text:
Foreground color (NSForegroundColorAttributeName), background color
(NSBackgroundColorAttributeName), and underline
(NSUnderlineAttributeName).
This release provides more sophisticated programmatic interaction between the user and the input methods, including allowing an input method to track mouse events on text.
When Developer Release 2 ships, Apple's Developer Support web site will make available source code for a sample input method that uses the new APIs to implement a hex input method (allowing you to type a hex number to specify any Unicode character).
By invoking setAutosaveTableColumns: you can get the
column configuration (such as ordering and sizes) of a table or
outline view to be saved, per user, under a key specified via
setAutosaveName:. This works much like the frame saving
feature in NSWindow. Outline view also provides an additional method,
setAutosaveExpandedItems:, to let applications save the
expansion state of the viewed data. To enable this, you will also
have to respond to the new data-source methods that allow the outline
view to archive the items.
Additional delegate methods and notifications in NSOutlineView allow instances to communicate expansion and collapsing of items.
The printing method knowsPagesFirst:last: has been
deprecated in favor of knowsPageRange:, which is easier
to map to Java. The old method will keep on working but will no
longer be documented.
Invoke setAllowsUndo:with an argument of YES to
enable undo in the text system.
If you write your own connection inspector for IB, you may wish to use the NSNibControlConnector, NSNibOutletConnector, and the NSNibConnector classes. NSNibControlConnector provides a target/action connection between objects in a nib file. NSNibOutletConnector provides an outlet connection between objects in a nib file. NSNibConnector is the common base class; you may wish to subclass it for your own custom connectors between objects.
DataLinks, which were made obsolete between NextStep and OPENSTEP releases, have been removed from the framework.
NSComboBoxCell now provides automatic completion of typing.
The way keyboard UI is started on Rhapsody has been modified. In windows without editable textfields, hitting Tab will enter you into keyboard UI mode; until that time, keyboard focus will not be on any UI object. In windows with editable textfields, if an initial first responder has not been specified, the textfield will have the focus when the window is brought up. On Windows the situation is as it was; that is, it works like Windows does.
On Rhapsody, Command-up-arrow and Command-down-arrow used to change the ordering of windows (without making them key). This is no longer the case.
Consider NSCStringText and all related API (everything in obsoleteNSCStringText.h) to be deprecated. Although this code will keep working for awhile, it is highly recommended that you switch over to the new text system, which provides much more functionality in a much cleaner way. If there are any reasons that prevent you from moving to the new text system, please let us know through Developer Support.
In DR1, the Application Kit includes these new classes, features, and changes since OpenStep 4.2:
A class for objects that represent PICT images. For the Developer Release, only bitmap PICTs work.
A class for objects that implement a determinate or indeterminate progress indicator. The indeterminate progress indicator can be animated in a separate thread, allowing its use even in computation code that doesn't use the run loop.
Classes for displaying multiple views using tabs.
A subclass of NSTableView that implements an outline representation of hierarchical data. Like NSTableView and NSBrowser objects, NSOutlineView objects use a data source (separate from the delegate) to display the data lazily.
New factory methods create objects that represent additional user interface colors.
As does the Font panel, the Color panel now has a Set button. When
clicked, it sends a changeColor: message down the
responder chain. See the NSColorPanel documentation for details.
The systemFontOfSize: and
boldSystemFontOfSize: methods have been deprecated in
favor of the other factory methods returning user-chosen fonts. The
function NSConvertGlyphsToPackedGlyphs() was added to
allow you to convert an array of NSGlyphs to "packed" glyphs,
suitable for passing to PostScript.
NSImage and NSBitmapImageRep can now read GIF, JPEG, and PNG images directly (that is, without the aid of filter services). JPEG and PNG writing is also supported; GIF writing is planned for a future release. Some APIs were added to NSBitmapImageRep to provide support for features found in these image file types.
These two classes help provide a more complete abstraction in the Application Kit framework layer for graphics operations. NSBezierPath enables standard operations with lines, user-defined paths, and arrays of glyphs, such as stroking, filling, and clipping. It also provides simple bounds computation and hit detection methods. NSAffineTransform provides an abstraction for the graphics transformation matrix.
The abstract superclass for NSDPSContext, this class provides methods to save and restore the graphics state and to change the current graphics context.
The look and feel of the split view has changed significantly.
There's no dimple, the split bar is thinner, and you get a resize
image when the cursor is over it. You should use the method
dividerThickness to determine the correct thickness of
the bar.
The new method visibleFrame supplies the usable
region (without menu or task bar regions) of a given screen.
Menus and pop-up buttons have changed significantly since OpenStep 4.2. In 4.2, NSMenu and NSMenuItem claimed they were NSObject subclasses, but they were actually subclasses of NSPanel and NSButtonCell. Although the compiler would warn about panel or cell messages being sent to these objects, they would perform as required at run time. In the new implementation, NSMenu and NSMenuItem are true subclasses of NSObject. If your code is sending messages to these objects—which assume inheritance from NSPanel and NSButtonCell—it will no longer work.
NSMenu and NSMenuItem include new APIs and functionality.
NSMenuItems may now have titles, key equivalents, images, and state
images. NSMenus have a platform-specific menu representation that is
in charge of presenting the menu to the user and allowing the user to
interact with it. On Mach, the menu representation is an NSMenuView.
NSMenuView allows much leeway in the way a menu works and looks. An
NSMenuView uses NSMenuItemCells to draw its items. On Windows the
menu representation class is currently private (NSMenu's
menuRepresentation method will return nil).
The NSMenuItem protocol has been deprecated in favor of the NSMenuItem class. Use the class instead of the protocol, which will be dropped from the Application Kit in a future release. There is now a public NSPopUpButtonCell class. See the Application Kit reference documentation for details of the new APIs.
Some planned features are not yet implemented, such as tear offs and key-equivalent overrides. You should not have to do anything special to prepare your application for these coming features. Context menus are supported in the Developer Release, but only for systems with two-button mice. Support will be added in a later release support for Control-click context menus. Your code should not have to change, but you should be aware that using the control key for your own special mouse features is probably not a good idea since that modifier key will soon have another meaning.
Sliders now support tick marks that identify specific values on the slider continuum. Clicking these tick marks returns the represented value.
NSTextView objects can now read HTML files. A delegate method is provided for following HTML links.
Delegate methods for clicking on cells have been augmented with an
argument to specify the character index of the click; for
instance, textView:clickedOnCell:inRect:atIndex: instead
of textView:clickedOnCell:inRect:. The old delegate
methods will continue to work, but you should plan to replace them
with the new ones.
The text system now treats control-L ("form feed") as a container break character. A control-L forces the layout to continue onto the next container. However, the text system also tries to recognize the infinitely-growing container case (which is the usual situation in applications such as TextEdit and Project Builder), and ignores the control-L in these cases.
On non-Windows platforms, an application can now choose to quit
when the last window is closed. If the application delegate responds
to applicationShouldTerminateAfterLastWindowClosed: by
returning YES, the application is sent a terminate:
message when the last window is closed.
On Windows systems there has been no change. If the last window of
an application is closed, and if the window contained the application
menu, the application is sent the terminate: message by
default. The delegate can prevent this by responding NO to
applicationShouldTerminateAfterLastWindowClosed:.
Instead of miniaturizing, windows now use a feature called WindowShading: when the user clicks the appropriate window control, the window's content view disappears and just the title bar remains (this can be toggled back to the original state). Windows also have a zoom button, which switches a window between a standard (size-to-fit) size and a user size. The standard size can be set by calls to the delegate.
A document icon in the title bar gives access to the document represented by the window; users can drag and drop the document directly (this replaces the "Alternate-drag from the miniaturize button" model of OPENSTEP 4.2).
Two new methods in NSView, didAddSubview: and
willRemoveSubview:, provide ways to detect subview list
changes.
These classes now support mixed-state cells. You can enable this
feature with the setAllowsMixedState: method, which
allows the cell to be in NSMixedState mode in addition to NSOnState
and NSOffState. In addition, various bezel styles have been added to
support the range of button styles available on the Mac:
(Although the header file refers to NSNeXTBezelStyle, NSPushButtonBezelStyle, NSSmallIconButtonBezelStyle, NSMediumIconButtonBezelStyle, and NSLargeIconButtonBezelStyle, these styles are obsolete and should not be used.)
The Rhapsody Developer release contains an alpha version of the Java APIs for the Yellow Box. By using these APIs you can access virtually all classes and protocols of the Application Kit and Foundation frameworks. However, since this is an alpha version, these APIs are not yet complete and will most likely change before the next release.
The constant NSMacintoshInterfaceStyle has been added to represent the Rhapsody user interface. NSNextStepInterfaceStyle has been removed.
When creating resources, use the suffixes "-macintosh" and
"-windows" to indicate any resources that are specific to a
particular interface style. The base resource must be available (for
instance, foo.nib); all the other interface-style
specific ones (such as foo-windows.nib) are optional.
This is a feature of NSBundle, and will work with any resource, not
just nibs.
This section is provided as a quick guide to developers converting applications from NextStep 3.x to the Yellow Box. OpenStep 4.2 was the last release shipped by NeXT before the Apple purchase.
OpenStep: Release 4.0 brings numerous API changes to the
AppKit relative to Release 3.3. Tools and scripts provided to convert
a 3.x application to OpenStep are included with the 4.x releases, in
/NextLibrary/Documentation/NextDev/Conversion/ConversionGuide..
New Text System: Release 4.0 includes a new text system composed of several different classes: NSTextView (front-end UI), NSTextStorage and NSAttributedString (back-end text storage), NSLayoutManager (management of text layout process and info), and NSTextContainer (description of text flow areas). These classes provide an open, powerful interface and allow text editing in multiple languages, using the Unicode standard.
FileWrapper: NSFileWrapper, a new class, provides support for the concept of a document wrapper (like a .rtfd or ..nib). It handles reading and writing file packages in the file system as well as serializing them for use with the Pasteboard.
TableView: DBKit's table view class has been completely rewritten and moved into the AppKit as NSTableView. All four classes making up the new TableView are public and fully subclassable.
Keyboard UI: Keyboard access is now provided to most of the controls in the AppKit.
Formatting and Validation: Cells may now be assigned arbitrary object values, which are converted into presentation strings by associated formatter objects. This allows the developer to directly set an NSDate, for instance, as the value of a cell. The cell's associated date formatter will present a localized string representation of the date to the user. The formatter objects, along with control delegates, can also perform validation on user-entered data, thereby restricting entries to valid ranges or quantities.
Rich Text in Cells: NSCell and subclasses can now display and edit rich text. The rich text is specified via instances of NSAttributedString. The new formatting/validation API also includes support for attributed strings.
RulerView: NSRulerView is designed as a general-purpose ruler that can be associated with any scroll view and used by any view that's in the scroll view. It supports both horizontal and vertical rulers, allows arbitrary markers along the rule, and can accept an accessory view.
System Colors: New API has been added to access system-defined colors, such as the color of buttons, controls, text and text selection colors. On Windows, where the user can change the system colors at any point, these colors will change at runtime to match the user's selection.
Image: NSImage now understands the bmp, ico, and cur image formats. ico and cur files with multiple images will be loaded as images with multiple representations. Typically these representations will have different sizes (unlike multiple-representation tiffs, which have different depths); by default, NSImage will choose the largest image when compositing.
NSApplicationMain: The AppKit now provides a function NSApplicationMain() to take care of the initialization and startup of your application. This function is declared in NSApplication.h.
ObjectLinks: ObjectLinks have been removed from the OpenStep specification, and in general the feature is not supported in OpenStep for Mach or Windows.
Help System: The AppKit's Help API has changed significantly. NSHelpPanel has been obsoleted in favor of a new class, NSHelpManager, which provides a more platform-independent approach to presenting both context-sensitive and comprehensive help.
ComboBox: NSComboBox class has been added to the Application Kit. It offers functionality that is similar to the Combo Box control used in the Microsoft Windows user interface.
Splash Screen: OpenStep for Windows now provides support
for a "splash" screen in applications; this is basically a panel that
comes up with a static image as the application is launched. To use
this feature, simply provide an 8-bit uncompressed bitmap (.bmp)
image named Splash.bmp as a resource in your
application. You can make it localizable if you wish (thus the image
can be either in
appname.app/Resources/ or
appname.app/Resources/language.lproj/)
NSApplication: By default, on OpenStep for Windows, only a
single copy of an application will be launched. If you wish to run
multiple copies, you should use specify a value of NO to the
-NSUseRunningCopy command line option. In addition, all
command-line options that are not defaults options (meaning a pair of
arguments where the first one starts with a "-") are now treated as
file names to be opened, as if they were prefixed with
-NSOpen. As a result of these two changes, you can now
associate documents with OpenStep applications on Windows simply by
specifying the location of the application. The default command line
provided by the Explorer suffices to open documents and also to
connect to a running copy of the application, if there is one.
Window edited status: In OpenStep for Windows, an asterisk in a window's title bar indicates that the associated document has been edited.
Tracking rectangles: Tracking rectangles are now implemented on Windows.
NSWindow frame vs content rect: On Windows, the frameRect and contentRect of an NSWindow are currently the same size. Thus the frameRect of an NSWindow does not include the title bar, menu bar, resize border, and so on (but does on Mach). Also, the contentView while a window is miniaturized is an NSImageView, not the original contentView. The contentView is restored when the window is deminiaturized.
NSTextView: On Windows, to allow entering a character
without an appropriate keyboard, you can now use the
Alternate key in conjunction with the digit keys from
the keypad. While holding down the Alternate key, type the index of
the desired character in the encoding of the current font (in most
cases this will be the NEXTSTEP encoding). The appropriate character
will be inserted into the text when the Alternate key is released.
SplitView: NSSplitView now supports horizontal as well vertical splits.
ToolTips: It's now possible to add "tooltips" (short help messages that pop up as the user holds the mouse cursor over an item) to views. You can do this programmatically or by using Interface Builder's Help panel.
Text Hyphenation and Justification: The text object now supports full justification and hyphenation, with a fairly basic API.
ComboBox cell: There is now a public NSComboBoxCell class. This feature allows you to use combo boxes in table views, among other places.
Hiding applications on Windows: Support for the "hide application" command has been added to OpenStep for Windows. The default menu item for this is Minimize All in the Windows menu (with Control-h as the key equivalent). The Application Kit adds this item automatically if it is not in the menu.
CMYK archiving problem: A bug in
decodeNXColor that caused CMYK colors from 3.x
archives to be read incorrectly in 4.0 and 4.1 has been fixed. (The
colors were way off base; instead of C, M, Y, K, the values 1-C, 1-M,
1-Y, and 1-K were used.)